Python DRF ದೃಢೀಕರಣ: ದೃಢವಾದ API ಗಳಿಗಾಗಿ ಟೋಕನ್ vs. JWT ಅನುಷ್ಠಾನ

ನಿಮ್ಮ API ಗಳನ್ನು ಸುರಕ್ಷಿತಗೊಳಿಸುವುದು ಅತ್ಯಂತ ಮುಖ್ಯವಾಗಿದೆ. Python ಮತ್ತು Django REST Framework (DRF) ನೊಂದಿಗೆ API ಗಳನ್ನು ನಿರ್ಮಿಸುವಾಗ, ನೀವು ಹಲವಾರು ದೃಢೀಕರಣ ಆಯ್ಕೆಗಳನ್ನು ಹೊಂದಿದ್ದೀರಿ. ಈ ಲೇಖನವು ಎರಡು ಜನಪ್ರಿಯ ವಿಧಾನಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ: ಟೋಕನ್ ದೃಢೀಕರಣ ಮತ್ತು JWT (JSON ವೆಬ್ ಟೋಕನ್) ದೃಢೀಕರಣ, ಅವುಗಳ ಅನುಕೂಲಗಳು ಮತ್ತು ಅನಾನುಕೂಲಗಳನ್ನು ಹೋಲಿಸುತ್ತದೆ, ಮತ್ತು ಪ್ರಾಯೋಗಿಕ ಅನುಷ್ಠಾನ ಉದಾಹರಣೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

API ಗಳಲ್ಲಿ ದೃಢೀಕರಣವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ದೃಢೀಕರಣವು ನಿಮ್ಮ API ಗಳನ್ನು ಪ್ರವೇಶಿಸುವ ಬಳಕೆದಾರ ಅಥವಾ ಅಪ್ಲಿಕೇಶನ್‌ನ ಗುರುತನ್ನು ಪರಿಶೀಲಿಸುವ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ. ಉತ್ತಮವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾದ ದೃಢೀಕರಣ ವ್ಯವಸ್ಥೆಯು ಅಧಿಕೃತ ಘಟಕಗಳು ಮಾತ್ರ ರಕ್ಷಿತ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. RESTful API ಗಳು ಸಂದರ್ಭದಲ್ಲಿ, ದೃಢೀಕರಣವು ಸಾಮಾನ್ಯವಾಗಿ ಪ್ರತಿ ವಿನಂತಿಯೊಂದಿಗೆ ರುಜುವಾತುಗಳನ್ನು (ಉದಾ., ಬಳಕೆದಾರ ಹೆಸರು ಮತ್ತು ಪಾಸ್‌ವರ್ಡ್) ಕಳುಹಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಸರ್ವರ್ ನಂತರ ಈ ರುಜುವಾತುಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು, ಮಾನ್ಯವಾಗಿದ್ದರೆ, ಪ್ರವೇಶವನ್ನು ನೀಡುತ್ತದೆ.

ಟೋಕನ್ ದೃಢೀಕರಣ

ಟೋಕನ್ ದೃಢೀಕರಣವು ಸರಳ ಮತ್ತು ನೇರವಾದ ಕಾರ್ಯವಿಧಾನವಾಗಿದೆ. ಬಳಕೆದಾರರು ಯಶಸ್ವಿಯಾಗಿ ಲಾಗಿನ್ ಆದಾಗ, ಸರ್ವರ್ ಒಂದು ಅನನ್ಯ, ಯಾದೃಚ್ಛಿಕ ಟೋಕನ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ, ಬಳಕೆದಾರರೊಂದಿಗೆ ಅದನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ. ಕ್ಲೈಂಟ್ ನಂತರ ಈ ಟೋಕನ್ ಅನ್ನು ಮುಂದಿನ ವಿನಂತಿಗಳ 'Authorization' ಹೆಡರ್‌ನಲ್ಲಿ ಕಳುಹಿಸುತ್ತದೆ. ಸರ್ವರ್ ಡೇಟಾಬೇಸ್‌ನಿಂದ ಟೋಕನ್ ಅನ್ನು ಮರಳಿ ಪಡೆಯುತ್ತದೆ, ಅದರ ಮಾನ್ಯತೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಮತ್ತು ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಪ್ರವೇಶವನ್ನು ನೀಡುತ್ತದೆ.

DRF ನೊಂದಿಗೆ ಅನುಷ್ಠಾನ

DRF ಟೋಕನ್ ದೃಢೀಕರಣಕ್ಕಾಗಿ ಅಂತರ್ನಿರ್ಮಿತ ಬೆಂಬಲವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಅದನ್ನು ಹೇಗೆ ಅಳವಡಿಸುವುದು ಎಂಬುದು ಇಲ್ಲಿದೆ:

1. DRF ಅನ್ನು ಸ್ಥಾಪಿಸಿ ಮತ್ತು ನಿಮ್ಮ Django ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ ನೋಂದಾಯಿಸಿ:

ಮೊದಲು, ನೀವು Django REST Framework ಅನ್ನು ಸ್ಥಾಪಿಸಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ:

            pip install djangorestframework
            

              
                Copy
              
            
          

ನಂತರ, ನಿಮ್ಮ `settings.py` ನಲ್ಲಿರುವ `INSTALLED_APPS` ಗೆ ಅದನ್ನು ಸೇರಿಸಿ:

            INSTALLED_APPS = [
    ...
    'rest_framework',
]
            

              
                Copy
              
            
          

2. ಡೀಫಾಲ್ಟ್ ದೃಢೀಕರಣ ವರ್ಗವಾಗಿ TokenAuthentication ಸ್ಕೀಮ್ ಅನ್ನು ಸೇರಿಸಿ (ಐಚ್ಛಿಕ, ಆದರೆ ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ):

ನಿಮ್ಮ `settings.py` ಫೈಲ್‌ನಲ್ಲಿ, ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಸೇರಿಸಿ:

            REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.TokenAuthentication',
        'rest_framework.authentication.SessionAuthentication',
    ],
}

            

              
                Copy
              
            
          

ಇದು ನಿಮ್ಮ API ಯಾದ್ಯಂತ ಟೋಕನ್ ದೃಢೀಕರಣವನ್ನು ಜಾಗತಿಕವಾಗಿ ಅನ್ವಯಿಸುತ್ತದೆ. `SessionAuthentication` ಬ್ರೌಸರ್-ಆಧಾರಿತ ಸಂವಹನಕ್ಕಾಗಿ ಸೇರಿಸಲಾಗಿದೆ, ಆದರೆ ನೀವು ಸಂಪೂರ್ಣ API-ಚಾಲಿತ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಅದನ್ನು ತೆಗೆದುಹಾಕಬಹುದು.

3. ಪ್ರತಿ ಬಳಕೆದಾರರಿಗೆ ಟೋಕನ್ ರಚಿಸಿ:

ನೀವು ಸಿಗ್ನಲ್ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಬಳಕೆದಾರರ ರಚನೆಯ ಸಮಯದಲ್ಲಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಟೋಕನ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ `signals.py` ಎಂಬ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ (ಉದಾ., `users/signals.py`):

            from django.conf import settings
from django.db.models.signals import post_save
from django.dispatch import receiver
from rest_framework.authtoken.models import Token

@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def create_auth_token(sender, instance=None, created=False, **kwargs):
    if created:
        Token.objects.create(user=instance)

            

              
                Copy
              
            
          

ನಂತರ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಕಾನ್ಫಿಗರೇಶನ್ ವರ್ಗದ `ready` ವಿಧಾನದಲ್ಲಿ ಈ `signals.py` ಫೈಲ್ ಅನ್ನು ನಿಮ್ಮ `users/apps.py` ಫೈಲ್‌ನಲ್ಲಿ ಆಮದು ಮಾಡಿಕೊಳ್ಳಿ. `users/apps.py` ಗಾಗಿ ಉದಾಹರಣೆ:

            from django.apps import AppConfig

class UsersConfig(AppConfig):
    default_auto_field = 'django.db.BigAutoField'
    name = 'users'

    def ready(self):
        import users.signals

            

              
                Copy
              
            
          

ಈಗ ನೀವು ಕಮಾಂಡ್ ಲೈನ್ ಬಳಸಿಕೊಂಡು ಟೋಕನ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಬಹುದು:

            python manage.py drf_create_token <username>

            

              
                Copy
              
            
          

4. ನಿಮ್ಮ API ವ್ಯೂಗಳನ್ನು ಅಳವಡಿಸಿ:

ಟೋಕನ್ ದೃಢೀಕರಣದ ಅಗತ್ಯವಿರುವ ಒಂದು ಸರಳ ಉದಾಹರಣೆಯ ವ್ಯೂ ಇಲ್ಲಿದೆ:

            from rest_framework import permissions
from rest_framework.response import Response
from rest_framework.views import APIView

class ExampleView(APIView):
    authentication_classes = [TokenAuthentication]
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request):
        content = {
            'message': 'Hello, ' + request.user.username + '! You are authenticated.',
        }
        return Response(content)

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, `authentication_classes` ಟೋಕನ್ ದೃಢೀಕರಣವನ್ನು ಬಳಸಬೇಕು ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ, ಮತ್ತು `permission_classes` ಕೇವಲ ದೃಢೀಕೃತ ಬಳಕೆದಾರರು ಮಾತ್ರ ವ್ಯೂ ಅನ್ನು ಪ್ರವೇಶಿಸಬಹುದು ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.

5. Login API View ಅನ್ನು ಸೇರಿಸಿ:

ಯಶಸ್ವಿ ಲಾಗಿನ್ ಆದ ನಂತರ ಟೋಕನ್ ರಚಿಸಲು ನಿಮಗೆ ಒಂದು ಎಂಡ್‌ಪಾಯಿಂಟ್ ಕೂಡ ಬೇಕಾಗುತ್ತದೆ:

            from django.contrib.auth import authenticate
from rest_framework import status
from rest_framework.authtoken.models import Token
from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import AllowAny
from rest_framework.response import Response

@api_view(['POST'])
@permission_classes([AllowAny])
def login(request):
    username = request.data.get('username')
    password = request.data.get('password')
    user = authenticate(username=username, password=password)
    if user:
        token, _ = Token.objects.get_or_create(user=user)
        return Response({'token': token.key})
    else:
        return Response({'error': 'Invalid Credentials'}, status=status.HTTP_401_UNAUTHORIZED})

            

              
                Copy
              
            
          

ಟೋಕನ್ ದೃಢೀಕರಣದ ಅನುಕೂಲಗಳು

• ಸರಳತೆ: ಅಳವಡಿಸಲು ಮತ್ತು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸುಲಭ.
• ಸ್ಥಿತಿರಹಿತ: ಪ್ರತಿ ಟೋಕನ್ ವಿನಂತಿಯು ಅದನ್ನು ಸ್ವತಂತ್ರವಾಗಿ ನಿಲ್ಲಲು ಅನುಮತಿಸುವ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಟೋಕನ್ ದೃಢೀಕರಣದ ಅನಾನುಕೂಲಗಳು

• ಡೇಟಾಬೇಸ್ ಅವಲಂಬನೆ: ಟೋಕನ್ ಅನ್ನು ಪರಿಶೀಲಿಸಲು ಪ್ರತಿ ವಿನಂತಿಗೆ ಡೇಟಾಬೇಸ್ ಲುಕಪ್ ಅಗತ್ಯವಿದೆ. ಇದು ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಬಹುದು, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಪ್ರಮಾಣದಲ್ಲಿ.
• ಟೋಕನ್ ರದ್ದತಿ: ಟೋಕನ್ ಅನ್ನು ರದ್ದುಗೊಳಿಸಲು ಅದನ್ನು ಡೇಟಾಬೇಸ್‌ನಿಂದ ಅಳಿಸಬೇಕಾಗುತ್ತದೆ, ಇದು ಸಂಕೀರ್ಣವಾಗಬಹುದು.
• ಸ್కేಲಬಿಲಿಟಿ: ಡೇಟಾಬೇಸ್ ಓವರ್‌ಹೆಡ್‌ನಿಂದಾಗಿ ದೊಡ್ಡ, ಹೆಚ್ಚಿನ-ಟ್ರಾಫಿಕ್ API ಗಳಿಗೆ ಇದು ಅತ್ಯಂತ ಸ್ಕೇಲಬಲ್ ಪರಿಹಾರವಾಗಿರುವುದಿಲ್ಲ.

JWT (JSON ವೆಬ್ ಟೋಕನ್) ದೃಢೀಕರಣ

JWT ದೃಢೀಕರಣವು ಹೆಚ್ಚು ಆಧುನಿಕ ಮತ್ತು ಅತ್ಯಾಧುನಿಕ ವಿಧಾನವಾಗಿದೆ. JWT ಒಂದು ಸಂಕ್ಷಿಪ್ತ, URL-ಸುರಕ್ಷಿತ JSON ವಸ್ತುವಾಗಿದ್ದು, ಬಳಕೆದಾರರ ಬಗ್ಗೆ ಕ್ಲೈಮ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಈ ಕ್ಲೈಮ್‌ಗಳನ್ನು ರಹಸ್ಯ ಕೀ ಅಥವಾ ಸಾರ್ವಜನಿಕ/ಖಾಸಗಿ ಕೀ ಜೋಡಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಡಿಜಿಟಲ್ ಆಗಿ ಸಹಿ ಮಾಡಲಾಗುತ್ತದೆ. ಬಳಕೆದಾರರು ಲಾಗಿನ್ ಆದಾಗ, ಸರ್ವರ್ JWT ಅನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಕ್ಲೈಂಟ್‌ಗೆ ಕಳುಹಿಸುತ್ತದೆ. ಕ್ಲೈಂಟ್ ನಂತರ ಈ JWT ಅನ್ನು ಮುಂದಿನ ವಿನಂತಿಗಳ 'Authorization' ಹೆಡರ್‌ನಲ್ಲಿ ಸೇರಿಸುತ್ತದೆ. ಸರ್ವರ್ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಸಂಪರ್ಕಿಸದೆಯೇ JWT ಯ ಸಹಿಯನ್ನು ಪರಿಶೀಲಿಸಬಹುದು, ಇದು ಹೆಚ್ಚು ಸಮರ್ಥ ಮತ್ತು ಸ್ಕೇಲಬಲ್ ಪರಿಹಾರವಾಗಿದೆ.

DRF ನೊಂದಿಗೆ ಅನುಷ್ಠಾನ

DRF JWT ದೃಢೀಕರಣಕ್ಕಾಗಿ ಅಂತರ್ನಿರ್ಮಿತ ಬೆಂಬಲವನ್ನು ಒದಗಿಸುವುದಿಲ್ಲ, ಆದರೆ ಹಲವಾರು ಅತ್ಯುತ್ತಮ ಲೈಬ್ರರಿಗಳು ಅದನ್ನು ಸುಲಭವಾಗಿ ಸಂಯೋಜಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತವೆ. ಅತ್ಯಂತ ಜನಪ್ರಿಯವಾದದ್ದು `djangorestframework-simplejwt`.

1. `djangorestframework-simplejwt` ಅನ್ನು ಸ್ಥಾಪಿಸಿ:

            pip install djangorestframework-simplejwt
            

              
                Copy
              
            
          

2. DRF ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿ:

ನಿಮ್ಮ `settings.py` ಫೈಲ್‌ನಲ್ಲಿ, ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಸೇರಿಸಿ:

            REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework_simplejwt.authentication.JWTAuthentication',
        'rest_framework.authentication.SessionAuthentication',
    ),
}

SIMPLE_JWT = {
    'ACCESS_TOKEN_LIFETIME': timedelta(minutes=5),
    'REFRESH_TOKEN_LIFETIME': timedelta(days=1),
    'ROTATE_REFRESH_TOKENS': False,
    'BLACKLIST_AFTER_ROTATION': True,

    'ALGORITHM': 'HS256',
    'SIGNING_KEY': settings.SECRET_KEY,
    'VERIFYING_KEY': None,
    'AUTH_HEADER_TYPES': ('Bearer',),
    'USER_ID_FIELD': 'id',
    'USER_ID_CLAIM': 'user_id',

    'AUTH_TOKEN_CLASSES': ('rest_framework_simplejwt.tokens.AccessToken',),
    'TOKEN_TYPE_CLAIM': 'token_type',
}

            

              
                Copy
              
            
          

ಸೆಟ್ಟಿಂಗ್‌ಗಳ ವಿವರಣೆ:

• `ACCESS_TOKEN_LIFETIME`: ಪ್ರವೇಶ ಟೋಕನ್ ಎಷ್ಟು ಸಮಯದವರೆಗೆ ಮಾನ್ಯವಾಗಿರುತ್ತದೆ (ಉದಾಹರಣೆ, 5 ನಿಮಿಷಗಳು).
• `REFRESH_TOKEN_LIFETIME`: ರಿಫ್ರೆಶ್ ಟೋಕನ್ ಎಷ್ಟು ಸಮಯದವರೆಗೆ ಮಾನ್ಯವಾಗಿರುತ್ತದೆ (ಉದಾಹರಣೆ, 1 ದಿನ). ಬಳಕೆದಾರರು ಮತ್ತೆ ಲಾಗಿನ್ ಆಗದೆಯೇ ಹೊಸ ಪ್ರವೇಶ ಟೋಕನ್‌ಗಳನ್ನು ಪಡೆಯಲು ರಿಫ್ರೆಶ್ ಟೋಕನ್‌ಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.
• `ROTATE_REFRESH_TOKENS`: ಪ್ರತಿ ಬಳಕೆಯ ನಂತರ ರಿಫ್ರೆಶ್ ಟೋಕನ್‌ಗಳನ್ನು ತಿರುಗಿಸಬೇಕೆ.
• `BLACKLIST_AFTER_ROTATION`: ತಿರುಗುವಿಕೆಯ ನಂತರ ಹಳೆಯ ರಿಫ್ರೆಶ್ ಟೋಕನ್‌ಗಳನ್ನು ಕಪ್ಪುಪಟ್ಟಿಗೆ ಸೇರಿಸಬೇಕೆ.
• `ALGORITHM`: JWT ಗೆ ಸಹಿ ಮಾಡಲು ಬಳಸುವ ಅಲ್ಗಾರಿದಮ್ (HS256 ಒಂದು ಸಾಮಾನ್ಯ ಆಯ್ಕೆಯಾಗಿದೆ).
• `SIGNING_KEY`: JWT ಗೆ ಸಹಿ ಮಾಡಲು ಬಳಸುವ ರಹಸ್ಯ ಕೀ (ಸಾಮಾನ್ಯವಾಗಿ ನಿಮ್ಮ Django SECRET_KEY).
• `AUTH_HEADER_TYPES`: ದೃಢೀಕರಣ ಹೆಡರ್‌ನ ಪ್ರಕಾರ (ಸಾಮಾನ್ಯವಾಗಿ "Bearer").

3. Login ಮತ್ತು Refresh Token API ವ್ಯೂಗಳನ್ನು ಸೇರಿಸಿ:

`djangorestframework-simplejwt` ಟೋಕನ್‌ಗಳನ್ನು ಪಡೆಯಲು ಮತ್ತು ರಿಫ್ರೆಶ್ ಮಾಡಲು ವ್ಯೂಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಅವುಗಳನ್ನು ನಿಮ್ಮ `urls.py` ನಲ್ಲಿ ಸೇರಿಸಿ:

            from django.urls import path
from rest_framework_simplejwt.views import (
    TokenObtainPairView,
    TokenRefreshView,
)

urlpatterns = [
    path('token/', TokenObtainPairView.as_view(), name='token_obtain_pair'),
    path('token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),
]

            

              
                Copy
              
            
          

`TokenObtainPairView` ಯಶಸ್ವಿ ದೃಢೀಕರಣದ ನಂತರ ಪ್ರವೇಶ ಮತ್ತು ರಿಫ್ರೆಶ್ ಟೋಕನ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. `TokenRefreshView` ಮಾನ್ಯವಾದ ರಿಫ್ರೆಶ್ ಟೋಕನ್ ಒದಗಿಸಿದಾಗ ಹೊಸ ಪ್ರವೇಶ ಟೋಕನ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.

4. ನಿಮ್ಮ API ವ್ಯೂಗಳನ್ನು ಅಳವಡಿಸಿ:

JWT ದೃಢೀಕರಣದ ಅಗತ್ಯವಿರುವ ಒಂದು ಸರಳ ಉದಾಹರಣೆಯ ವ್ಯೂ ಇಲ್ಲಿದೆ:

            from rest_framework import permissions
from rest_framework.response import Response
from rest_framework.views import APIView
from rest_framework_simplejwt.authentication import JWTAuthentication

class ExampleView(APIView):
    authentication_classes = [JWTAuthentication]
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request):
        content = {
            'message': 'Hello, ' + request.user.username + '! You are authenticated.',
        }
        return Response(content)

            

              
                Copy
              
            
          

ಟೋಕನ್ ದೃಢೀಕರಣ ಉದಾಹರಣೆಯಂತೆಯೇ, `authentication_classes` JWT ದೃಢೀಕರಣವನ್ನು ಬಳಸಬೇಕು ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ, ಮತ್ತು `permission_classes` ಕೇವಲ ದೃಢೀಕೃತ ಬಳಕೆದಾರರಿಗೆ ಮಾತ್ರ ಪ್ರವೇಶವನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತದೆ.

JWT ದೃಢೀಕರಣದ ಅನುಕೂಲಗಳು

• ಸ್కేಲಬಿಲಿಟಿ: ಟೋಕನ್ ಪರಿಶೀಲನೆಗೆ ಡೇಟಾಬೇಸ್ ಲುಕಪ್ ಅಗತ್ಯವಿಲ್ಲ, ಇದು ಹೆಚ್ಚು ಸ್ಕೇಲಬಲ್ ಆಗಿರುತ್ತದೆ.
• ಸ್ಥಿತಿರಹಿತ: JWT ದೃಢೀಕರಣಕ್ಕಾಗಿ ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.
• ಪ್ರಮಾಣೀಕೃತ: JWT ಅನೇಕ ಲೈಬ್ರರಿಗಳು ಮತ್ತು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಿಂದ ಬೆಂಬಲಿತವಾದ ವ್ಯಾಪಕವಾಗಿ ಅಳವಡಿಸಿಕೊಂಡಿರುವ ಮಾನದಂಡವಾಗಿದೆ.
• ಮೈಕ್ರೋಸರ್ವಿಸಸ್ ಸ್ನೇಹಿ: ಮೈಕ್ರೋಸರ್ವಿಸಸ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ, ಏಕೆಂದರೆ ಸೇವೆಗಳು ಸ್ವತಂತ್ರವಾಗಿ JWT ಗಳನ್ನು ಪರಿಶೀಲಿಸಬಹುದು.

JWT ದೃಢೀಕರಣದ ಅನಾನುಕೂಲಗಳು

• ಸಂಕೀರ್ಣತೆ: ಟೋಕನ್ ದೃಢೀಕರಣಕ್ಕಿಂತ ಅಳವಡಿಸಲು ಹೆಚ್ಚು ಸಂಕೀರ್ಣ.
• ಟೋಕನ್ ಗಾತ್ರ: JWT ಗಳು ಸರಳ ಟೋಕನ್‌ಗಳಿಗಿಂತ ದೊಡ್ಡದಾಗಿರಬಹುದು, ಸಂಭಾವ್ಯವಾಗಿ ಬ್ಯಾಂಡ್‌ವಿಡ್ತ್ ಬಳಕೆಯನ್ನು ಹೆಚ್ಚಿಸಬಹುದು.
• ಟೋಕನ್ ರದ್ದತಿ: JWT ಯನ್ನು ರದ್ದುಗೊಳಿಸುವುದು ಸವಾಲಾಗಿದೆ. ಒಮ್ಮೆ ನೀಡಿದರೆ, ಅದು ಅದರ ಅವಧಿ ಮುಗಿಯುವವರೆಗೆ ಮಾನ್ಯವಾಗಿರುತ್ತದೆ. ರದ್ದುಗೊಂಡ ಟೋಕನ್‌ಗಳನ್ನು ಕಪ್ಪುಪಟ್ಟಿಗೆ ಸೇರಿಸುವುದರ ಮೂಲಕ ಪರಿಹಾರಗಳು ಸಾಧ್ಯ, ಇದು ಮತ್ತೆ ಡೇಟಾಬೇಸ್ ಅವಲಂಬನೆಯನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ.

ಟೋಕನ್ ರದ್ದತಿ ತಂತ್ರಗಳು

ಟೋಕನ್ ಮತ್ತು JWT ದೃಢೀಕರಣ ವಿಧಾನಗಳು ಎರಡೂ ಪ್ರವೇಶವನ್ನು ರದ್ದುಗೊಳಿಸಲು ಕಾರ್ಯವಿಧಾನಗಳು ಅಗತ್ಯವಿದೆ. ಟೋಕನ್ ರದ್ದತಿ ವಿಧಾನವನ್ನು ಹೇಗೆ ಸಮೀಪಿಸಬಹುದು ಎಂಬುದು ಇಲ್ಲಿದೆ:

ಟೋಕನ್ ದೃಢೀಕರಣ ರದ್ದತಿ

ಟೋಕನ್ ದೃಢೀಕರಣದೊಂದಿಗೆ, ರದ್ದತಿ ನೇರವಾಗಿರುತ್ತದೆ: ಡೇಟಾಬೇಸ್‌ನಿಂದ ಟೋಕನ್ ಅನ್ನು ಅಳಿಸಿ:

            from rest_framework.authtoken.models import Token

try:
    token = Token.objects.get(user=request.user)
    token.delete()
except Token.DoesNotExist:
    pass

            

              
                Copy
              
            
          

JWT ದೃಢೀಕರಣ ರದ್ದತಿ

JWT ರದ್ದತಿ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿದೆ ಏಕೆಂದರೆ ಟೋಕನ್ ಸ್ವತಃ ಸ್ವಯಂಪೂರ್ಣವಾಗಿದೆ ಮತ್ತು (ಆರಂಭದಲ್ಲಿ) ಪರಿಶೀಲನೆಗಾಗಿ ಡೇಟಾಬೇಸ್ ಲುಕಪ್ ಅನ್ನು ಅವಲಂಬಿಸುವುದಿಲ್ಲ. ಸಾಮಾನ್ಯ ತಂತ್ರಗಳು ಸೇರಿವೆ:

• ಟೋಕನ್ ಕಪ್ಪುಪಟ್ಟಿಗೆ ಸೇರಿಸುವಿಕೆ: ರದ್ದುಗೊಂಡ ಟೋಕನ್‌ಗಳನ್ನು ಕಪ್ಪುಪಟ್ಟಿಯಲ್ಲಿ (ಉದಾ., ಡೇಟಾಬೇಸ್ ಟೇಬಲ್ ಅಥವಾ Redis ಕ್ಯಾಶೆ) ಸಂಗ್ರಹಿಸಿ. JWT ಅನ್ನು ಪರಿಶೀಲಿಸುವ ಮೊದಲು, ಅದು ಕಪ್ಪುಪಟ್ಟಿಯಲ್ಲಿ ಇದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ. `djangorestframework-simplejwt` ರಿಫ್ರೆಶ್ ಟೋಕನ್‌ಗಳನ್ನು ಕಪ್ಪುಪಟ್ಟಿಗೆ ಸೇರಿಸಲು ಅಂತರ್ನಿರ್ಮಿತ ಬೆಂಬಲವನ್ನು ಒದಗಿಸುತ್ತದೆ.
• ಸಣ್ಣ ಅವಧಿ ಮುಕ್ತಾಯ ಸಮಯಗಳು: ಸಣ್ಣ ಪ್ರವೇಶ ಟೋಕನ್ ಅವಧಿ ಮುಕ್ತಾಯ ಸಮಯಗಳನ್ನು ಬಳಸಿ ಮತ್ತು ಹೊಸ ಪ್ರವೇಶ ಟೋಕನ್‌ಗಳನ್ನು ಆಗಾಗ್ಗೆ ಪಡೆಯಲು ರಿಫ್ರೆಶ್ ಟೋಕನ್‌ಗಳ ಮೇಲೆ ಅವಲಂಬಿತರಾಗಿರಿ. ಇದು ರಾಜಿ ಮಾಡಿಕೊಂಡ ಟೋಕನ್ ಅನ್ನು ಬಳಸಲು ಅವಕಾಶದ ಅವಧಿಯನ್ನು ಮಿತಿಗೊಳಿಸುತ್ತದೆ.
• ರಿಫ್ರೆಶ್ ಟೋಕನ್‌ಗಳನ್ನು ತಿರುಗಿಸಿ: ಪ್ರತಿ ಬಳಕೆಯ ನಂತರ ರಿಫ್ರೆಶ್ ಟೋಕನ್‌ಗಳನ್ನು ತಿರುಗಿಸಿ. ಇದು ಹಳೆಯ ಟೋಕನ್‌ಗಳನ್ನು ಪ್ರತಿ ಬಾರಿಯೂ ಅಮಾನ್ಯಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಟೋಕನ್ ಕಳ್ಳತನವನ್ನು ತಡೆಯುತ್ತದೆ.

OAuth2 ಮತ್ತು OpenID Connect

ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ದೃಢೀಕರಣ ಮತ್ತು ದೃಢೀಕರಣ ಸಂದರ್ಭಗಳಿಗಾಗಿ, OAuth2 ಮತ್ತು OpenID Connect ಅನ್ನು ಪರಿಗಣಿಸಿ. ಈ ಮಾನದಂಡಗಳು ರುಜುವಾತುಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳದೆಯೇ ಸಂಪನ್ಮೂಲಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ನಿಯೋಜಿಸಲು ಒಂದು ದೃಢವಾದ ಚೌಕಟ್ಟನ್ನು ಒದಗಿಸುತ್ತವೆ. OAuth2 ಪ್ರಾಥಮಿಕವಾಗಿ ದೃಢೀಕರಣ ಪ್ರೋಟೋಕಾಲ್ ಆಗಿದೆ, ಆದರೆ OpenID Connect ದೃಢೀಕರಣ ಸೇವೆಗಳನ್ನು ಒದಗಿಸಲು OAuth2 ಅನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ. `django-oauth-toolkit` ಮತ್ತು `django-allauth` ನಂತಹ ಹಲವಾರು Django ಪ್ಯಾಕೇಜುಗಳು ನಿಮ್ಮ DRF API ಗಳಲ್ಲಿ OAuth2 ಮತ್ತು OpenID Connect ನ ಸಂಯೋಜನೆಯನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತವೆ.

ಉದಾಹರಣೆ ಸಂದರ್ಭ: ಬಳಕೆದಾರರು ನಿಮ್ಮ API ಯಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ತಮ್ಮ ಡೇಟಾಗೆ ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಪ್ರವೇಶವನ್ನು ನೀಡಲು ಬಯಸುತ್ತಾರೆ. OAuth2 ನೊಂದಿಗೆ, ಬಳಕೆದಾರರು ತಮ್ಮ ಬಳಕೆದಾರ ಹೆಸರು ಮತ್ತು ಪಾಸ್‌ವರ್ಡ್ ಅನ್ನು ಹಂಚಿಕೊಳ್ಳದೆಯೇ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಅಧಿಕಾರ ನೀಡಬಹುದು. ಬದಲಾಗಿ, ಅಪ್ಲಿಕೇಶನ್ ಬಳಕೆದಾರರ ಡೇಟಾವನ್ನು ಅನುಮತಿಯ ವ್ಯಾಖ್ಯಾನಿತ ವ್ಯಾಪ್ತಿಯೊಳಗೆ ಪ್ರವೇಶಿಸಲು ಬಳಸಬಹುದಾದ ಪ್ರವೇಶ ಟೋಕನ್ ಅನ್ನು ಪಡೆಯುತ್ತದೆ.

ಸರಿಯಾದ ದೃಢೀಕರಣ ವಿಧಾನವನ್ನು ಆರಿಸುವುದು

ಉತ್ತಮ ದೃಢೀಕರಣ ವಿಧಾನವು ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಅವಶ್ಯಕತೆಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ:

• ಸರಳತೆ ಮತ್ತು ಅನುಷ್ಠಾನದ ವೇಗ: ಟೋಕನ್ ದೃಢೀಕರಣವು ಸಾಮಾನ್ಯವಾಗಿ ಪ್ರಾರಂಭದಲ್ಲಿ ಅಳವಡಿಸಲು ಸುಲಭವಾಗಿದೆ.
• ಸ್కేಲಬಿಲಿಟಿ: JWT ದೃಢೀಕರಣವು ಹೆಚ್ಚಿನ-ಟ್ರಾಫಿಕ್ API ಗಳಿಗೆ ಹೆಚ್ಚು ಸ್ಕೇಲಬಲ್ ಆಗಿದೆ.
• ಸುರಕ್ಷತಾ ಅವಶ್ಯಕತೆಗಳು: ನಿಮ್ಮ ಡೇಟಾದ ಸೂಕ್ಷ್ಮತೆ ಮತ್ತು ಅಗತ್ಯವಿರುವ ಸುರಕ್ಷತಾ ಮಟ್ಟವನ್ನು ಪರಿಗಣಿಸಿ. OAuth2/OpenID Connect ಹೆಚ್ಚು ದೃಢವಾದ ಸುರಕ್ಷತಾ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ ಆದರೆ ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಅನುಷ್ಠಾನದ ಅಗತ್ಯವಿದೆ.
• ಮೈಕ್ರೋಸರ್ವಿಸಸ್ ಆರ್ಕಿಟೆಕ್ಚರ್: JWT ಗಳು ಮೈಕ್ರೋಸರ್ವಿಸಸ್‌ಗಳಿಗೆ ಸೂಕ್ತವಾಗಿವೆ, ಏಕೆಂದರೆ ಪ್ರತಿ ಸೇವೆಯು ಟೋಕನ್‌ಗಳನ್ನು ಸ್ವತಂತ್ರವಾಗಿ ಪರಿಶೀಲಿಸಬಹುದು.

API ದೃಢೀಕರಣಕ್ಕಾಗಿ ಅತ್ಯುತ್ತಮ ಅಭ್ಯಾಸಗಳು

• HTTPS ಅನ್ನು ಬಳಸಿ: ಕ್ಲೈಂಟ್ ಮತ್ತು ಸರ್ವರ್ ನಡುವಿನ ಸಂವಹನವನ್ನು ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡಲು ಯಾವಾಗಲೂ HTTPS ಅನ್ನು ಬಳಸಿ, ರುಜುವಾತುಗಳನ್ನು ಕಣ್ಣಿಟ್ಟು ಕೇಳುವುದರಿಂದ ರಕ್ಷಿಸುತ್ತದೆ.
• ರಹಸ್ಯಗಳನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಸಂಗ್ರಹಿಸಿ: ರಹಸ್ಯ ಕೀಗಳು ಅಥವಾ ಪಾಸ್‌ವರ್ಡ್‌ಗಳನ್ನು ಎಂದಿಗೂ ಪ್ಲೈನ್ ಟೆಕ್ಸ್ಟ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಬೇಡಿ. ಪರಿಸರ ವೇರಿಯೇಬಲ್‌ಗಳು ಅಥವಾ ಸುರಕ್ಷಿತ ಕಾನ್ಫಿಗರೇಶನ್ ನಿರ್ವಹಣೆ ಸಾಧನಗಳನ್ನು ಬಳಸಿ.
• ರೇಟ್ ಲಿಮಿಟಿಂಗ್ ಅನ್ನು ಅಳವಡಿಸಿ: ನಿರ್ದಿಷ್ಟ ಸಮಯಾವಧಿಯಲ್ಲಿ ಕ್ಲೈಂಟ್ ಮಾಡಬಹುದಾದ ವಿನಂತಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ಬಂಧಿಸಲು ರೇಟ್ ಲಿಮಿಟಿಂಗ್ ಅನ್ನು ಅಳವಡಿಸುವ ಮೂಲಕ ನಿಮ್ಮ API ಅನ್ನು ದುರುಪಯೋಗದಿಂದ ರಕ್ಷಿಸಿ.
• ಇನ್‌ಪುಟ್ ಅನ್ನು ಪರಿಶೀಲಿಸಿ: ಇಂಜೆಕ್ಷನ್ ದಾಳಿಗಳನ್ನು ತಡೆಯಲು ಎಲ್ಲಾ ಇನ್‌ಪುಟ್ ಡೇಟಾವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪರಿಶೀಲಿಸಿ.
• ಪర్యವೇಕ್ಷಿಸಿ ಮತ್ತು ಲಾಗ್ ಮಾಡಿ: ಅನುಮಾನಾಸ್ಪದ ಚಟುವಟಿಕೆಗಾಗಿ ನಿಮ್ಮ API ಅನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಿ ಮತ್ತು ಲೆಕ್ಕಪರಿಶೋಧನೆ ಉದ್ದೇಶಗಳಿಗಾಗಿ ದೃಢೀಕರಣ ಈವೆಂಟ್‌ಗಳನ್ನು ಲಾಗ್ ಮಾಡಿ.
• ಲೈಬ್ರರಿಗಳನ್ನು ನಿಯಮಿತವಾಗಿ ನವೀಕರಿಸಿ: ಸುರಕ್ಷತಾ ಪ್ಯಾಚ್‌ಗಳು ಮತ್ತು ಸುಧಾರಣೆಗಳಿಂದ ಪ್ರಯೋಜನ ಪಡೆಯಲು ನಿಮ್ಮ Django, DRF, ಮತ್ತು ದೃಢೀಕರಣ ಲೈಬ್ರರಿಗಳನ್ನು ನವೀಕರಿಸಿ.
• CORS (Cross-Origin Resource Sharing) ಅನ್ನು ಅಳವಡಿಸಿ: ವೆಬ್ ಬ್ರೌಸರ್‌ಗಳಿಂದ ನಿಮ್ಮ API ಅನ್ನು ಪ್ರವೇಶಿಸಲು ವಿಶ್ವಾಸಾರ್ಹ ಡೊಮೇನ್‌ಗಳನ್ನು ಮಾತ್ರ ಅನುಮತಿಸಲು CORS ಅನ್ನು ಸರಿಯಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಿ.

ತೀರ್ಮಾನ

ನಿಮ್ಮ DRF API ಗಳನ್ನು ಸುರಕ್ಷಿತಗೊಳಿಸಲು ಸೂಕ್ತವಾದ ದೃಢೀಕರಣ ವಿಧಾನವನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು ಅತ್ಯಗತ್ಯ. ಟೋಕನ್ ದೃಢೀಕರಣವು ಸರಳತೆಯನ್ನು ನೀಡುತ್ತದೆ, ಆದರೆ JWT ದೃಢೀಕರಣವು ಸ್ಕೇಲಬಿಲಿಟಿ ಮತ್ತು ನಮ್ಯತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಪ್ರತಿ ವಿಧಾನದ ಅನುಕೂಲಗಳು ಮತ್ತು ಅನಾನುಕೂಲಗಳನ್ನು, API ಸುರಕ್ಷತೆಗಾಗಿ ಅತ್ಯುತ್ತಮ ಅಭ್ಯಾಸಗಳೊಂದಿಗೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು, ನಿಮ್ಮ ಡೇಟಾ ಮತ್ತು ಬಳಕೆದಾರರನ್ನು ರಕ್ಷಿಸುವ ದೃಢವಾದ ಮತ್ತು ಸುರಕ್ಷಿತ API ಗಳನ್ನು ನಿರ್ಮಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳನ್ನು ಪರಿಗಣಿಸಲು ಮರೆಯದಿರಿ ಮತ್ತು ಸುರಕ್ಷತೆ, ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಅನುಷ್ಠಾನದ ಸುಲಭದ ನಡುವೆ ಸಮತೋಲನವನ್ನು ಉತ್ತಮವಾಗಿ ಸಾಧಿಸುವ ಪರಿಹಾರವನ್ನು ಆರಿಸಿ. ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ದೃಢೀಕರಣ ಸಂದರ್ಭಗಳಿಗಾಗಿ OAuth2 ಮತ್ತು OpenID Connect ಅನ್ನು ಅನ್ವೇಷಿಸಿ.